package com.smart.community.property.service;

import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cache.annotation.Cacheable;
import org.springframework.stereotype.Service;

import java.util.List;
import java.util.concurrent.ConcurrentHashMap;

/**
 * 物业公司权限缓存服务
 * @author Wu.Liang
 * @date 2025-01-29
 * @version 1.0
 */
@Slf4j
@Service
public class PropertyCompanyPermissionCacheService {

    // 缓存过期时间（毫秒）
    private static final long CACHE_EXPIRE_TIME = 5 * 60 * 1000; // 5分钟

    // 本地缓存，用于存储权限检查结果
    private final ConcurrentHashMap<String, Object> permissionCache = new ConcurrentHashMap<>();
    
    // 缓存时间戳
    private final ConcurrentHashMap<String, Long> cacheTimestamp = new ConcurrentHashMap<>();

    @Autowired
    private DataScopeService dataScopeService;

    /**
     * 检查用户是否有物业公司权限（带缓存）
     * @param userId 用户ID
     * @param propertyCompanyId 物业公司ID
     * @return 是否有权限
     * @throws Exception 
     */
    @Cacheable(value = "permission", key = "'property_company_' + #userId + '_' + #propertyCompanyId")
    public boolean hasPropertyCompanyPermission(Long userId, Long propertyCompanyId) throws Exception {
        String cacheKey = userId + "_" + propertyCompanyId;
        
        // 从缓存获取
        Object cachedResult = permissionCache.get(cacheKey);
        if (cachedResult instanceof Boolean) {
            // 权限检查: 使用缓存结果 - 已隐藏详细日志
            return (Boolean) cachedResult;
        }

        // 检查缓存是否过期
        if (isCacheExpired(cacheKey)) {
            permissionCache.remove(cacheKey);
            cacheTimestamp.remove(cacheKey);
        }

        // 执行权限检查
        boolean hasPermission = dataScopeService.hasPropertyCompanyPermission(userId, propertyCompanyId);
        
        // 缓存结果
        permissionCache.put(cacheKey, hasPermission);
        cacheTimestamp.put(cacheKey, System.currentTimeMillis());
        
        // 权限检查结果已缓存 - 已隐藏详细日志
        
        return hasPermission;
    }

    /**
     * 检查当前用户是否为超级管理员（带缓存）
     * @param userId 用户ID
     * @return 是否为超级管理员
     * @throws Exception 
     */
    @Cacheable(value = "permission", key = "'super_admin_' + #userId")
    public boolean isCurrentUserSuperAdmin(Long userId) throws Exception {
        String cacheKey = "super_admin_" + userId;
        
        // 从缓存获取
        Object cachedResult = permissionCache.get(cacheKey);
        if (cachedResult instanceof Boolean) {
            // 超级管理员检查: 使用缓存结果 - 已隐藏详细日志
            return (Boolean) cachedResult;
        }

        // 检查缓存是否过期
        if (isCacheExpired(cacheKey)) {
            permissionCache.remove(cacheKey);
            cacheTimestamp.remove(cacheKey);
        }

        // 执行检查
        boolean isSuperAdmin = dataScopeService.isUserSuperAdmin(userId);
        
        // 缓存结果
        permissionCache.put(cacheKey, isSuperAdmin);
        cacheTimestamp.put(cacheKey, System.currentTimeMillis());
        
        // 超级管理员检查结果已缓存 - 已隐藏详细日志
        
        return isSuperAdmin;
    }

    /**
     * 获取用户关联的物业公司ID列表（带缓存）
     * @param userId 用户ID
     * @return 物业公司ID列表
     * @throws Exception 
     */
    @Cacheable(value = "permission", key = "'user_property_companies_' + #userId")
    public List<Long> getCurrentUserPropertyCompanyIds(Long userId) throws Exception {
        String cacheKey = "user_property_companies_" + userId;
        
        // 从缓存获取
        Object cachedResult = permissionCache.get(cacheKey);
        if (cachedResult instanceof List) {
            @SuppressWarnings("unchecked")
            List<Long> result = (List<Long>) cachedResult;
            // 用户物业公司列表: 使用缓存结果 - 已隐藏详细日志
            return result;
        }

        // 检查缓存是否过期
        if (isCacheExpired(cacheKey)) {
            permissionCache.remove(cacheKey);
            cacheTimestamp.remove(cacheKey);
        }

        // 执行查询
        List<Long> propertyCompanyIds = dataScopeService.getUserPropertyCompanyIds(userId);
        
        // 缓存结果
        permissionCache.put(cacheKey, propertyCompanyIds);
        cacheTimestamp.put(cacheKey, System.currentTimeMillis());
        
        // 用户物业公司列表已缓存 - 已隐藏详细日志
        
        return propertyCompanyIds;
    }

    /**
     * 清除指定用户的权限缓存
     * @param userId 用户ID
     */
    public void clearUserPermissionCache(Long userId) {
        log.info("清除用户权限缓存，用户ID：{}", userId);
        
        // 清除相关缓存
        permissionCache.entrySet().removeIf(entry -> {
            String key = entry.getKey();
            return key.startsWith(userId + "_") || 
                   key.equals("super_admin_" + userId) || 
                   key.equals("user_property_companies_" + userId);
        });
        
        // 清除时间戳缓存
        cacheTimestamp.entrySet().removeIf(entry -> {
            String key = entry.getKey();
            return key.startsWith(userId + "_") || 
                   key.equals("super_admin_" + userId) || 
                   key.equals("user_property_companies_" + userId);
        });
    }

    /**
     * 清除所有权限缓存
     */
    public void clearAllPermissionCache() {
        log.info("清除所有权限缓存");
        permissionCache.clear();
        cacheTimestamp.clear();
    }

    /**
     * 获取缓存统计信息
     */
    public void getCacheStatistics() {
        log.info("=== 权限缓存统计 ===");
        log.info("缓存条目数: {}", permissionCache.size());
        log.info("时间戳条目数: {}", cacheTimestamp.size());
        log.info("缓存大小: {} KB", (permissionCache.size() * 64) / 1024); // 估算大小
    }

    /**
     * 检查缓存是否过期
     * @param cacheKey 缓存键
     * @return 是否过期
     */
    private boolean isCacheExpired(String cacheKey) {
        Long timestamp = cacheTimestamp.get(cacheKey);
        if (timestamp == null) {
            return true;
        }
        long currentTime = System.currentTimeMillis();
        return (currentTime - timestamp) > CACHE_EXPIRE_TIME;
    }
}
